Rewrite the Algorithm section so a reader unfamiliar with the filter
can follow the two-phase pipeline end-to-end:

* Phase 1 (feature removal): motivate why small features get pruned,
  describe the 64K-tuple chunked scan, and explain the "skip write
  when chunk unchanged" optimization
* Phase 2 (gap fill by majority-vote): teach the rolling 3-slice
  buffer scan, the sparse parallel vectors that replace the old
  O(n) dense index array, the per-array ChunkedTransferWorker with
  its +/-1 Z-margin slab read + interior-only write-back, and the
  outer ParallelTaskAlgorithm across arrays
* Add a memory-footprint summary clarifying that every data
  structure is O(slice) or O(iteration bad count), never O(volume)

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

Add a new Algorithm section that teaches the filter from scratch:

* Explain conceptually which triangles are kept (all three vertices
  inside the user-specified node-type range) and what the output
  geometry looks like (compact vertex list, compact triangle list,
  remapped connectivity)
* Document the downstream-invariant that forces vertNewIndex to stay
  a dense per-vertex map (triangle 0's three fresh vertices land at
  new indices 0..2 in traversal order)
* Explain the triMask bitset + triPrefixSum sparse popcount table
  that replaces the legacy dense triangle map for ~6.4x memory
  savings, and how remapIndex() turns an O(1) table lookup plus a
  small popcount into each triangle's compact new index
* Walk the six streaming passes (vertex-ok mask, triangle scan +
  vertex-index assignment, prefix-sum build, vertex copy, triangle
  remap copy, per-vertex/per-triangle attached-array copy)
* Summarize the memory footprint so the vertNewIndex dominance is
  clear on very large meshes

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

Add a comprehensive Algorithm section covering both the node-geometry
and image-geometry paths from first principles:

* Describe how every supported transform (rotation, scale, manual
  matrix, etc.) collapses to a single 4x4 homogeneous matrix M and
  how M composes with prior transforms
* Node geometries: walk the 16K-vertex chunked read -> multiply ->
  write pipeline and explain why in-place topology+attribute data
  is correct
* Image geometries: teach the re-gridding problem (why output voxels
  need to look up source values via M^-1), and contrast nearest-
  neighbor vs. trilinear interpolation
* Z-slice slab cache: analytically deriving the per-output-slice
  source-Z range and the +/-2 trilinear margin
* Sliding-window slab updates via memmove + delta copyIntoBuffer
  reads when consecutive output slices overlap heavily
* Intra-slice parallelism via ParallelDataAlgorithm with thread
  safety argued from shared-read + disjoint-write access patterns
  and per-thread pValues scratch

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

Add an Algorithm section that walks the chunked pipeline step-by-step
for a reader unfamiliar with the optimization:

* Establish the closed-form per-triangle math (0.5 * |(A-B) x (A-C)|)
  so there is no confusion about the compute
* Quantify the naive access pattern (six OOC chunk-cache hits per
  triangle, hundreds of millions of virtual dispatches on CT-scale
  meshes) to motivate the chunking
* Walk the five-step per-chunk pipeline: bulk triangle connectivity
  read -> analyze vertex-index span -> span-bounded bulk vertex
  coords read -> parallel compute on plain buffers -> bulk area
  write
* Explain the 16M-vertex span cap and the serial per-triangle
  fallback for pathological meshes
* Summarize memory footprint (bounded O(chunk), not O(mesh))

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

Rewrite the Algorithm section to fully teach the filter:

* State what the three output arrays (NumElements, Volume,
  EquivalentDiameter) represent and show the spherical/circular
  diameter formulas
* Image Geometry path: explain the uniform-voxel-volume shortcut
  that lets the filter skip per-voxel volume computations, then
  walk the 256K-tuple chunked count pass and the per-feature
  output pass; cover the 2D fallback rules and the
  two-empty-dimensions preflight error
* RectGrid path: contrast with the Image case, describe the
  lockstep FeatureIds + elementSizes chunked read, and explain
  why Kahan summation is needed to avoid float32 rounding error
  on billion-voxel volumes
* Justify the 256K chunk size choice based on HDF5 chunk-lookup
  overhead vs. L2 cache residency
* Summarize memory footprint

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

…x bool-mask bulk I/O

Three logically related changes that finish reconciling the rebased
branch with Nathan Young's PR BlueQuartzSoftware#1590 (ENH: Standardize 2D Image Handling)
and fix one resulting OOC perf cliff:

1. Wholesale port of PR BlueQuartzSoftware#1590's two algorithm rewrites into the renamed
   in-core dispatch variants:
   - ComputeFeatureNeighborsDirect.cpp gets Nathan's templated
     ComputeFeatureNeighborsFunctor<ImageDimensionStateT> and ProcessVoxels
     dispatcher in place of the OOC-commit-era custom in-core logic.
   - IdentifySampleBFS.cpp gets Nathan's templated IdentifySampleFunctor
     plus the corresponding ProcessVoxels dispatch.
   The Scanline OOC variant of ComputeFeatureNeighbors is updated to
   reference the namespaced VoxelNeighbors<Image3D>:: constants while
   preserving its Z-slice rolling-window bulk-I/O structure.

2. Reapply PR BlueQuartzSoftware#1590's constexpr/const cleanups across the algorithm
   files where the rebase took --theirs (the OOC commit version) at the
   2aa00ee conflict and dropped Nathan's small adjustments:
     SimplnxCore: ComputeBoundaryCellsDirect, ErodeDilateBadData,
       ErodeDilateCoordinationNumber, ErodeDilateMask,
       ReplaceElementAttributesWithNeighborValues,
       RequireMinimumSizeFeatures
     OrientationAnalysis: BadDataNeighborOrientationCheckWorklist,
       NeighborOrientationCorrelation
   The pattern is uniform: promote the inlined `6` neighbor-array sizes
   to use VoxelNeighbors<Image3D>::k_FaceNeighborCount via a local
   k_NumFaceNeighbors alias, make neighborVoxelIndexOffsets const,
   make faceNeighborInternalIdx constexpr, make isValidFaceNeighbor
   const where it is not mutated, drop the now-unused DataGroup.hpp
   include, and const-ify NeighborOrientationCorrelation's orientationOps.
   ComputeFeatureNeighborsFilter.md picks up Nathan's all-dimension
   note about user-set spacing for shared surface area calculation.

3. Fix a per-element OOC fallback in BadDataNeighborOrientationCheckScanline
   that was triggered whenever the input mask was a BoolArray rather
   than a UInt8Array. The previous code routed bool masks through
   maskCompare->isTrue / maskCompare->setValue per voxel per Z-slice,
   causing chunk thrashing under chunked OOC storage. The Small_IN100
   pipeline test (a 189x201x117 volume with a bool mask produced by
   MultiThresholdObjects) ran in 4.7 s on simplnx-Rel but 3+ minutes
   on simplnx-ooc-Rel. AbstractDataStore<bool> already exposes
   copyIntoBuffer/copyFromBuffer just like AbstractDataStore<uint8>;
   the comment claiming otherwise was stale. Resolve a typed
   AbstractDataStore<bool>* alongside the existing uint8 store pointer
   and route both load and write-back through bulk I/O, with a small
   per-slice std::unique_ptr<bool[]> scratch buffer bridging between
   the algorithm's uint8 slice buffers and the bool data store's typed
   bulk API. With this change Small_IN100 OOC drops to 4.6 s
   (~1.6x in-core, in line with normal OOC overhead).

Tests updated:
  - IdentifySampleTest.cpp adopts Nathan's PR BlueQuartzSoftware#1590 hand-built 2D Empty
    Z/Y/X Non-Square regression tests plus the parameterized
    identify_sample_v2 exemplar test and the SIMPL Backwards Compatibility
    test, all wrapped with the OOC dual-path pattern (ForceOocAlgorithmGuard
    + GENERATE(from_range(k_ForceOocTestValues))). The pre-existing
    200x200x200 large-scale OOC validation test is retained.

Verified: simplnx-Rel and simplnx-ooc-Rel preset builds both clean.
All 43 affected-filter tests pass on simplnx-Rel; all 86 affected-filter
tests pass on simplnx-ooc-Rel (regex covering ComputeFeatureNeighbors,
IdentifySample, BadDataNeighborOrientation, ComputeBoundaryCells,
ErodeDilate*, NeighborOrientationCorrelation,
ReplaceElementAttributesWithNeighborValues, RequireMinimumSizeFeatures).

* Replace CreateDataStore + CreateResolvedDataStore with a single
  resolver-aware CreateDataStore(DataStructure, DataPath, ...) that
  always consults the registered format resolver. Old explicit-format
  overload deleted.
* Replace CreateListStore similarly so NeighborList backing storage
  is OOC-eligible when the OOC plugin is loaded and thresholds permit.
* Inline action-layer caller in ArrayCreationUtilities::CreateArray
  using GetIOCollection().createDataStoreWithType directly.
* Migrate 23 CreateResolvedDataStore call sites (mechanical rename).
* Migrate 13 cell-level test fixtures that were silently in-memory in
  OOC builds to the resolver-aware path so OOC builds actually exercise
  OOC stores.
* Migrate 6 in-memory non-test callers (ComputeFeatureCentroids scratch
  buffers, HDF5 readers in DataStoreIO and DatasetIO) to direct
  std::make_shared<DataStore<T>> since they have no DataStructure
  context.
* Migrate 2 NeighborListIO HDF5 readers to std::make_shared<ListStore<T>>
  for the same reason (in-core branch of the import pipeline).
* Wire CreateNeighbors action helper through the resolver-aware
  CreateListStore.
* Rewrite IOFormat.cpp tests to exercise the resolver path.

ImageGeom and RectGridGeom findElementSizes now route through the new
CreateDataStore so the voxel-sizes array can go OOC for very large
structured grids. RectGridGeom's inner loop also refactored from
per-voxel setValue calls to per-axis precompute + Z-slice
copyFromBuffer to avoid catastrophic OOC perf when the array is
OOC-backed.

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

… Format tests

* DataIOCollection's constructor registers the OOC format via
  SimplnxOoc::registerIOManager under SIMPLNX_USE_OOC, so getManager("HDF5-OOC")
  resolves in the compile-time-switch OOC build.
* IOFormat: guard the in-core large-data-format preference tests to
  #ifndef SIMPLNX_USE_OOC (the OOC-build defaults are covered by SimplnxOoc's
  DataFormatPreferenceTest) and update the "not configured" assertion to the
  seeded k_InMemoryFormat default.

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

The rebase onto upstream/develop brought in the parallelized in-core
ComputeFeatureSizes (tbb::combinable thread-local accumulation), while the
OOC branch had replaced that loop with serial chunked bulk I/O. Rather than
discard either, split the algorithm into the established Direct/Scanline
dispatch pattern so each storage backing uses its optimal strategy.

* ComputeFeatureSizesDirect: in-core parallel accumulation (the upstream
  ParallelDataAlgorithm + tbb::combinable Kahan-summation implementation)
* ComputeFeatureSizesScanline: out-of-core chunked copyIntoBuffer streaming
  (renamed from the former single ComputeFeatureSizes implementation)
* ComputeFeatureSizes: thin DispatchAlgorithm<Direct, Scanline> dispatcher
  selecting on whether the FeatureIds array is out-of-core
* Register both new algorithm units in the SimplnxCore CMakeLists
* Exercise both paths in the existing tests via ForceOocAlgorithmGuard +
  GENERATE(from_range(k_ForceOocTestValues))

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

The in-core build previously forced SIMPLNX_TEST_ALGORITHM_PATH to InCoreOnly
whenever SIMPLNX_USE_OOC was OFF, on the assumption that no out-of-core paths
exist to test. That is no longer true: the Direct/Scanline dispatch classes
are always compiled into the plugins, and forcing the Scanline (OOC) path runs
it against in-core data via copyIntoBuffer (a plain std::copy here), staying
fast while verifying the OOC algorithm matches the in-core result.

* Only coerce the nonsensical OocOnly (1) to InCoreOnly (2) when OOC is off
* Allow Both (0) so a single in-core build can validate both algorithm paths

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

DatasetIO::createEmptyDataset created the dataset with no creation
property list, so out-of-core arrays large enough to take the two-step
streaming write (createEmptyDataset + hyperslab writes) were always
written contiguous and uncompressed, even when WriteOptions requested
compression. The single-shot writeSpan path already applied it.

* Build the dataset creation property list via BuildChunkedDeflateDcpl
  in createEmptyDataset, matching writeSpan
* Preserves the existing fall-throughs to contiguous storage for
  compression level 0 and for arrays below the small-array threshold

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

The "Recovery file with all in-core data" test hardcoded
StoreType::InMemory and relied on ambient preferences, so it failed
whenever forceOocData was set: under forceOoc, the recovery file's
inline arrays correctly load as out-of-core stores backed by the
recovery file itself.

* Assert the expected store type via RequireExpectedStoreType, which
  tracks the active large-data preferences (OutOfCore under forceOoc,
  InMemory otherwise)
* Correct stale comments that claimed OOC was not compiled in

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

Add MemoryBudgetManager::maxBudgetBytes() (max(min(total-6GiB, 0.95*total), 1GiB)) and make setBudgetBytes() clamp the upper bound and report whether it clamped. Deduplicate the platform total-RAM ifdef through Memory::GetTotalMemory().

Apply the --memory-budget override to the manager in nxrunner so the cap and the override actually take effect in headless runs (previously the override was written only to Preferences, which the manager never reads in CLI mode).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Replace the SIMPLNX_USE_OOC compile-time switch and the format/preference
plumbing that depended on it with runtime interfaces: an injectable store-format
resolver, IO-manager lifecycle hooks fanned out by DataIOCollection, and a
tri-state DataStorageMode preference. simplnx core no longer references any OOC
symbol or on-disk format name; out-of-core capability is supplied entirely by a
registered IO manager at runtime. 50 files changed, +1175 / -643 lines.

================================================================================
1. Store-format resolver abstraction
================================================================================
Files: src/simplnx/DataStructure/IO/Generic/IDataStoreFormatResolver.{hpp,cpp},
InMemoryFormatResolver.hpp, src/simplnx/Utilities/ArrayCreationUtilities.{hpp,cpp},
DataStoreUtilities.hpp, DataArrayUtilities.hpp, DataStructure.{hpp,cpp},
Filter/Actions/CreateNeighborListAction.{hpp,cpp}

Introduce IDataStoreFormatResolver, a const, thread-safe policy interface that
decides which registered format a soon-to-be-created array uses, returning ""
for the in-memory default. InMemoryFormatResolver is the trivial default policy.
ArrayCreationUtilities::ResolveStorageFormat becomes the single decision point
shared by every creation call site, applying a fixed order: the authoritative
unstructured/poly-geometry gate (ParentGeometrySupportsOoc) forces in-core,
then an explicit per-filter override wins, then the DataStructure's resolver
decides. DataStructure carries a per-instance resolver plus a lazily-seeded
process-wide default, neither serialized. CreateArray, CreateListStore, and
CreateNeighborListAction route through this helper; CreateNeighborListAction and
CreateNeighbors now thread an explicit dataFormat override through to the store.

================================================================================
2. Runtime IO-manager lifecycle hooks and DataIOCollection fan-out
================================================================================
Files: src/simplnx/DataStructure/IO/Generic/IDataIOManager.hpp,
DataIOCollection.{hpp,cpp}, IO/HDF5/DataStructureWriter.{hpp,cpp},
DataStructure/StringArray.{hpp,cpp}

Add no-op virtual lifecycle hooks to IDataIOManager (finalizesImport,
onImportFinalize, onRecoveryWrite, onFinalizeStores, setBaseDirectory,
shutdownManager) so an OOC manager can participate in import finalization,
recovery writes, store read-only transition, and shutdown without core knowing
the specifics. DataIOCollection aggregates these: finalizeStores now fans out to
every manager's hook instead of forwarding to a compiled-in SimplnxOoc call, and
new anyManagerFinalizesImport / onImportFinalize / onRecoveryWrite /
setBaseDirectory / shutdownManagers dispatch to the registered managers. The
HDF5 writer's recovery-write path calls the collection hook rather than a direct
SimplnxOoc function. StringArray gains an isPlaceholder() override.

================================================================================
3. DataStorageMode tri-state preference with legacy migration
================================================================================
Files: src/simplnx/Core/Preferences.{hpp,cpp}

Replace the largeDataFormat / forceOocData preference surface with a single
canonical DataStorageMode enum (Adaptive, ForceInCore, ForceOutOfCore) persisted
as an integer under data_storage_mode. The enum is deliberately OOC-vocabulary-
free: core states user intent, the OOC build maps it onto a concrete format.
dataStorageMode() is the single source of truth and migrates older preference
files from the retained legacy keys; useOocData() becomes a convenience view
(true unless ForceInCore). The cached m_UseOoc flag and checkUseOoc() are
removed.

================================================================================
4. Remove the SIMPLNX_USE_OOC compile-time switch from core
================================================================================
Files: CMakeLists.txt, cmake/SimplnxConfig.hpp.in, IO/HDF5/DataStoreIO.hpp,
Utilities/Parsing/DREAM3D/Dream3dIO.cpp

Drop the SIMPLNX_USE_OOC option, the SIMPLNX_OOC_SOURCE_DIR compile-in of the
private SimplnxOoc sources, and the OOC test-suite wiring from CMake. The
generated config header no longer defines the macro. All previously #ifdef'd
creation, spill-to-disk, and import code paths are now unconditional and route
through the runtime interfaces; the import path decides eager-vs-deferred load
via anyManagerFinalizesImport() instead of the macro.

================================================================================
5. Resolver-aware load overloads
================================================================================
Files: src/simplnx/Utilities/Parsing/DREAM3D/Dream3dIO.{hpp,cpp}

Add LoadDataStructure and LoadDataStructureArrays overloads that stamp a
per-DataStructure resolver before import finalization runs, so a caller (e.g. a
read-only visualization load) can direct arrays to disk-backed stores for fast
first-show. nullptr matches the existing no-resolver behavior.

================================================================================
6. Test migration and new coverage
================================================================================
Files: test/DataStoreFormatResolverTest.cpp, test/DataStorageModeMigrationTest.cpp,
test/CMakeLists.txt, test/IOFormat.cpp, test/Dream3dLoadingApiTest.cpp,
test/UnitTestCommon/UnitTestCommon.{hpp,cpp}, and the SimplnxCore /
OrientationAnalysis filter tests.

Migrate every test from setForceOocData/setLargeDataFormat to setDataStorageMode
/ DataStorageMode. PreferencesSentinel takes a DataStorageMode; the UnitTestCommon
load helper consults dataStorageMode() and anyManagerFinalizesImport(). New tests
cover the resolver (InMemoryFormatResolver, per-instance vs process-default
isolation, ParentGeometrySupportsOoc) and the legacy-key migration.

================================================================================
Verification
================================================================================
No build or test run was performed as part of this squash. The squash is
verified content-faithful: the squashed commit's tree is confirmed identical to
the original range tip (step 8).

…d_alloc -272 net)

Add a non-blocking preflight warning (-271) when an in-core array would exceed
currently-available RAM (OOC arrays excluded; EmptyDataStore::memoryUsage() now
reports 0 for out-of-core placeholders, format resolved in preflight via a shared
ResolveStorageFormat helper), and a std::bad_alloc safety net (-272) at the single
IFilter::execute -> executeImpl boundary so an out-of-memory condition is a clean
pipeline error instead of a crash. Additive to the existing -264 total-RAM hard block.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

After the out-of-core resolver refactor (f68689d), Dream3dIO.cpp exceeds MSVC's
default COMDAT section limit and fails to compile in Debug with C1128. /bigobj
raises the limit; Release was unaffected.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Replace the inline "Automatic" / "In Memory" strings in DataIOCollection with
k_AutomaticDisplayName / k_InMemoryDisplayName constants so the labels have a
single definition. No behavior change.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

SliceBufferedTransfer.hpp and SimplnxCore's IdentifySampleCommon.hpp were added on
this branch but never listed in any CMake, so they were invisible in the IDE. Add
them to SIMPLNX_HDRS and PLUGIN_EXTRA_SOURCES respectively, where the existing
source_group(TREE ...) auto-groups them (simplnx/Utilities, Filters/Algorithms).

Also lift simplnx_test's inline source list into a variable and source_group it
under "test" / "Generated", mirroring the plugin-test convention in
cmake/Plugin.cmake. No build/behavior change.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

zlib was previously present only transitively, through the hdf5
dependency's "zlib" feature. The out-of-core layer that consumers
compile into libsimplnx (via SimplnxOoc's OOC.cmake) now uses zlib
directly: DeflateChunkLoader inflates raw HDF5 deflate chunks with
uncompress() so chunk decompression can run in parallel, off the
global HDF5 mutex, and OOC.cmake links ZLIB::ZLIB via
find_package(ZLIB). Declaring zlib as a direct dependency records
that direct use in the manifest and keeps the build from silently
breaking if hdf5's feature set ever drops the transitive pull-in.

* Append each plugin's unit-test target to the SIMPLNX_UNIT_TEST_TARGETS
  global property in create_simplnx_plugin_unit_test()
* Lets consumer builds that include simplnx via add_subdirectory attach
  additional sources or settings to the test executables without simplnx
  knowing about the consumer

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

* Replace the per-cell loop over FeatureIds and CellPhases with
  chunk-sequential copyIntoBuffer reads (bounded 64K-tuple buffers) and
  a single bulk copyFromBuffer write of the feature-level result
* Replace the per-cell std::map lookup with feature-level vectors;
  warning semantics and output are unchanged (warning set membership is
  identical under previous-value comparison, and the last phase seen
  still wins)
* Move the cancel check to the per-chunk loop and add throttled
  progress messaging
* Request disk-backed stores in the filter test via PreferencesSentinel
  so the OOC build exercises the filter against HDF5-backed data
* Benchmark (748,800 cells): disk-backed stores 11.7 s -> 35 ms,
  in-memory stores 8 ms -> 1 ms

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

This reverts commit 1ea72d6.

…base

* Pass the ColorKey choice through the ComputeIPFColorsScanline
  generateIPFColor call so non-TSL color keys reach the OOC dispatch
  path (the in-core Direct path already forwarded it)
* Port the V&V ColorKey plumbing test to the LoadDataStructure API
  that replaced ImportDataStructureFromFile on this branch
* Drop a stale comment reference to the removed
  ImportDataStructureFromFile in Dream3dIO.cpp

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

* defaultBudgetBytes() returned 50% of RAM without checking
  maxBudgetBytes(), so on machines under 12 GiB the 6 GiB reserve made
  the cap smaller than the default (e.g. 7 GiB CI runners: 3.5 GiB
  default vs 1 GiB cap), failing the cap-and-clamping unit test
* The constructor seeds the budget directly from the default, so such
  machines also ran with an over-cap budget at startup
* Clamp the default to the cap; machines with 12 GiB or more are
  unaffected

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

* Bulk-read FeatureEulerAngles, FeaturePhases, and CrystalStructures into
  local vectors once via copyIntoBuffer, mirroring ComputeGBCDMetricBased
* The parallel triangle selector and the distinct-boundary loop index these
  arrays randomly by feature id; when they are out-of-core, per-element
  access turned every triangle into a disk/cache lookup
* Eliminates a ~3.3x out-of-core slowdown (20.5s -> 6.3s on the GBPD metric
  test) to match in-core speed, with no change to computed results

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

getBoundingBox() seeded the upper-right corner with
std::numeric_limits<float>::min() -- the smallest POSITIVE normal float
(~1.18e-38), not the most-negative value. For any node geometry whose
maximum coordinate on an axis is <= ~0 (e.g. centered at or below the
origin), the max corner never updated during the vertex walk, producing a
wrong/oversized bounding box. Geometries lying entirely in positive space
happened to work, which masked the bug.

Seed the upper corner with std::numeric_limits<float>::lowest() so the
max is computed correctly regardless of where the geometry sits.

Signed-off-by: Jessica Marquis <jessica.marquis@bluequartz.net>